/**
 * author: zhou
 * date: 2017.10.18
 * description: 登录中心
 * functions: {
 *      login: 登录
 * }
 * 
 */
// 系统用户分为1 超级管理员 2 学校用户 3 家长用户
// 统一登录方法
// 依据type字段进行区分,学校用户登录之后首先判断是否为系统管理员,系统管理员获取全部学校端菜单,其他用户则根据角色获取相对应的菜单列表
// 家长用户暂时获取全部家长端菜单
const   mongoPromise = require('../../core/mongo/mongoPromise'),
        utils        = require('../../utils/utils'),
        Store        = require('../../core/redis/store'),
        _            = require('lodash'),
        redis        = require('../../core/redis/redis'),
        redisPromise = require('../../core/redis/redisPromise'),
        User         = require('../../core/mongo/models/system/userModel'),
        Menu         = require('../../core/mongo/models/system/menuModel'),
        Role         = require('../../core/mongo/models/school/roleModel');
        

const loginController = {
    /**
     * 登录
     * @param {*} ctx 
     */
    async login(ctx) {
        const { username, password, client } = ctx.request.body.data;
        if (!username) {
            ctx.body = { success: false, message: '用户名不能为空', state: 10004 };
            return;
        }
        if (!password) {
            ctx.body = { success: false, message: '密码不能为空', state: 10004 };
            return;
        }
        if (!client) {
            ctx.body = { success: false, message: '用户登录客户端类别不能为空', state: 10004 };
            return;
        }
        if (client === 'system') {
            // 超级管理员登录
        } else if (client === 'school') {
            // 学校用户登录
            const param = {
                username,
                password: utils.encrpt(password, 'Well students!China future!'),
                type: 2,
                status: { $lt: 3 }
            };
            const query = User.findOne(param, { password: 0 })
                            .populate('schoolId')
                            .populate('subjectIds')
                            .populate('classIds')
                            .populate('gradeIds'); 
            const user = await mongoPromise(ctx, query);
            if (user) {
                // 如果账户被禁用,直接返回
                if (user.status === 2) {
                    ctx.body = { success: false, message: '抱歉,您的账户已被禁用,请联系系统管理员', state: 10005 };
                    return;
                }
                if (user.schoolId.status === 2) {
                    ctx.body = { success: false, message: '抱歉,您所在学校已被禁用,请联系系统管理员', state: 10005 };
                    return;
                }
                if (user.schoolId.status === 3) {
                    ctx.body = { success: false, message: '抱歉,您所在学校已被删除,请联系系统管理员', state: 10005 };
                    return;
                }
                // 如果是系统管理员,获取全部菜单列表
                // 如果是普通学校用户,根据角色获取菜单列表
                if (user.isSchoolManager) {
                    const menuQuery = Menu.find();
                    const menuResult = await mongoPromise(ctx, menuQuery);
                    if (menuResult && menuResult.length > 0) {
                        // 缓存session
                        const store = new Store({ key: "SESSIONID" });
                        const sessionId = await store.set(user);
                        const result = {
                            success: true,
                            data: {
                                user,
                                token: sessionId,
                                menus: loginController.formatMenus(menuResult)
                            },
                            state: 200
                        };
                        // 登录成功,更新登录数据
                        loginController.updateUserLoginInfo(ctx, user._id);
                        ctx.body = result;
                    } else {
                        ctx.body = { success: false, message: '抱歉,您的账户没有权限,请联系系统管理员', state: '10005'};
                        return;
                    }
                } else {
                    if (user.roleId) {
                        const query = Role.findById(user.roleId).populate('menuIds');
                        const roleResult = await mongoPromise(ctx, query);
                        if (roleResult && roleResult.menuIds.length > 0) {
                            // 缓存session
                            const store = new Store({ key: "SESSIONID" });
                            const sessionId = await store.set(user);
                            const result = {
                                success: true,
                                data: {
                                    user,
                                    token: sessionId,
                                    menus: loginController.formatMenus(roleResult.menuIds)
                                },
                                state: 200
                            };
                            // 登录成功,更新登录数据
                            loginController.updateUserLoginInfo(ctx, user._id);
                            ctx.body = result;
                        } else {
                            ctx.body = { success: false, message: '抱歉,您没有权限查看系统', state: 10005 };
                            return;
                        }
                    } else {
                        ctx.body = { success: false, message: '抱歉,您没有权限查看系统', state: 10005 };
                        return;
                    }
                }
            } else {
                ctx.body = { success: false, message: '抱歉,用户名或密码错误', state: 10005 };
                return;
            }
        } else if (client === 'parent') {
            // 家长登录
        } else {
            ctx.body = { success: false, message: '抱歉,用户类型错误', state: 10004 };
            return;
        }
    },
    /**
     * 更新用户登录信息
     * @param {*} ctx 
     */
    async updateUserLoginInfo(ctx, id) {
        // 更新用户登录信息
        const query = User.update({ _id: id }, {
            $inc: {
                loginCount: 1
            },
            $set: {
                isLogin: true,
                ip: ctx.ip,
                lastLoginTime: Date.now(),
                client: ctx.request.body.data ? ctx.request.body.data.client : ''
            }
        });
        mongoPromise(ctx, query);
    },
    /**
     * 将菜单转换成层级关系
     * @param {*} menus 
     */
    formatMenus(menus) {
        let oneMenuArr = [],
            twoMenuArr = [],
            thrMenuArr = [];
        for (let menu of menus) {
            if (menu.level === '1') {
                oneMenuArr.push(menu);
            }
            if (menu.level === '2') {
                twoMenuArr.push(menu);
            }
            if (menu.length === '3') {
                thrMenuArr.push(menu);
            }
        }
        for (let twoMenu of twoMenuArr) {
            twoMenu.children = _.filter(thrMenuArr, (m) => { return m.upLevel === twoMenu._id.toString() });
        }
        for (let oneMenu of oneMenuArr) {
            oneMenu.children = _.filter(twoMenuArr, (m) => { return m.upLevel === oneMenu._id.toString() });
        }
        return oneMenuArr;
    },
    /**
     * 退出登录
     * @param {*} ctx 
     */
    async logout(ctx) {
        const { token, id } = ctx.request.body.data;
        if (!token) {
            ctx.body = { success: false, message: '抱歉,token不能为空', state: 10004 };
            return;
        }
        if (!id) {
            ctx.body = { success: false, message: '抱歉,用户id不能为空', state: 10004 };
            return;
        }
        // 删除redis中数据
        const delPipeline = redis.pipeline().del(`SESSION:${token}`);
        const delResult = await redisPromise({}, delPipeline);
        if (delResult.length > 0 && delResult[0][1] === 1) {
            // 更新用户数据
            const query = User.update({
                $set: {
                    isLogin: false,
                    lastLogoutTime: Date.now()
                }
            });
            mongoPromise(ctx, query);
            ctx.body = { success: true, data: [], state: 200 };
        } else {
            ctx.body = { success: false, message: '抱歉,退出登录失败', state: 10008 };
        }
    }
};

module.exports = loginController;